home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / disk / cdrom / MusicBox-2.1bi.lha / MusicBox / MusicBoxSCSI.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-29  |  19.6 KB  |  744 lines
  1. /*
  2.  ##########################################################################
  3.  ####                                                                  ####
  4.  ####                        The MusicBox Project                      ####
  5.  ####                    ============================                  ####
  6.  ####                                                                  ####
  7.  #### MusicBoxSCSI.c                                                   ####
  8.  ####                                                                  ####
  9.  #### Version 2.1os  --  September 29, 2000                            ####
  10.  ####                                                                  ####
  11.  #### Copyright (C) 1994  Thomas Dreibholz                             ####
  12.  ####               2000  Molbachweg 7                                 ####
  13.  ####                     51674 Wiehl                                  ####
  14.  ####                     Germany                                      ####
  15.  ####                                                                  ####
  16.  ####                     EMail: Dreibholz@bigfoot.com                 ####
  17.  ####                     WWW:   http://www.bigfoot.com/~dreibholz     ####
  18.  ####                                                                  ####
  19.  ##########################################################################
  20. */
  21. /***************************************************************************
  22.  *                                                                         *
  23.  *   This program is free software; you can redistribute it and/or modify  *
  24.  *   it under the terms of the GNU General Public License as published by  *
  25.  *   the Free Software Foundation; either version 2 of the License, or     *
  26.  *   (at your option) any later version.                                   *
  27.  *                                                                         *
  28.  ***************************************************************************/
  29.  
  30. /* MusicBox SCSI-Steuerung */
  31.  
  32. #include "MusicBox.h"
  33.  
  34. extern struct Einstellungen  Einstellungen;
  35. extern struct List           Liste;
  36. extern struct Window        *CDPlayerWnd;
  37. extern struct Gadget        *CDPlayerGadgets[25];
  38. extern struct Katalog       *Katalog;
  39. extern struct DiskObject     AudioCD;
  40. extern BOOL                  IsIconify;
  41. extern BOOL                  LowRes;
  42.  
  43. void Wiedergabe();
  44. void SetzeLR();
  45. void Volumen();
  46. void AuswurfLock();
  47. void LeseStatus();
  48. void Continue();
  49.  
  50. void  LeereKatalog();
  51. UBYTE LadeKatalog();
  52. UBYTE SichereKatalog();
  53. void  ListeErstellen();
  54. void  ListeEntfernen();
  55.  
  56. struct IOExtTD  *io;
  57. struct SCSICmd  *scsi;
  58. struct MsgPort  *port;
  59. struct Remember *Remember=NULL;
  60. struct Remember *ListRemember=NULL;
  61. UBYTE           *buffer;
  62. UBYTE           *sense;
  63. LONG             dev=-1L;
  64.  
  65. struct ListenEintrag
  66. {
  67.  struct Node Node;
  68.  UBYTE       Text[58];
  69. };
  70.  
  71. struct CDStatus
  72. {
  73.  UBYTE pad00;
  74.  UBYTE AudioStatus;
  75.  UWORD Length;
  76.  UBYTE FormatCode;
  77.  UBYTE Flags;
  78.  UBYTE Track;
  79.  UBYTE Index;
  80.  ULONG Adresse;
  81.  ULONG RelAdresse;
  82. };
  83.  
  84. struct CDDriveInfo
  85. {
  86.  UBYTE PeripheralType;
  87.  UBYTE Modifier;
  88.  UBYTE Version;
  89.  UBYTE Flags1;
  90.  UBYTE AdditionalLength;
  91.  UBYTE reserved[2];
  92.  UBYTE Flags2;
  93.  UBYTE Vendor[8];
  94.  UBYTE Product[16];
  95.  UBYTE Revision[4];
  96. };
  97.  
  98. #define TOC_SIZE 804
  99.  
  100. struct TOCHeader
  101. {
  102.  WORD  Length;
  103.  UBYTE FirstTrack;
  104.  UBYTE LastTrack;
  105. };
  106.  
  107. struct TOCData
  108. {
  109.  UBYTE pad01;
  110.  UBYTE Flags;
  111.  UBYTE TrackNumber;
  112.  UBYTE pad02;
  113.  LONG  Adresse;
  114. };
  115.  
  116. struct TOCBlock
  117. {
  118.  struct TOCHeader TOCHeader;
  119.  struct TOCData   TOCData[];
  120. };
  121.  
  122. struct ModeData
  123. {
  124.  UBYTE Head[4];
  125.  UBYTE Page;
  126.  UBYTE PLength;
  127.  UBYTE b2,b3,b4,b5;
  128.  UWORD bps;
  129.  UBYTE Out0;
  130.  UBYTE Vol0;
  131.  UBYTE Out1;
  132.  UBYTE Vol1;
  133.  UBYTE pad[4];
  134. };
  135.  
  136. UBYTE PosTab[100];
  137. UBYTE MBTab[100];
  138.  
  139. UBYTE cmd_eject[10]    =  { 0xc4, 0x00, 0x00, 0x00, 0x00,
  140.                             0x00, 0x00, 0x00, 0x00, 0x00};
  141. UBYTE cmd_play[10]     =  { 0x48, 0x00, 0x00, 0x00, 0xff,
  142.                             0x01, 0x00, 0x63, 0x63, 0x00};
  143. UBYTE cmd_stop[6]      =  { 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00};
  144. UBYTE cmd_lock[6]      =  { 0x1e, 0x00, 0x00, 0x00, 0xff, 0x00};
  145. UBYTE cmd_playfrom[10] =  { 0x47, 0x00, 0x00, 0xff, 0xff,
  146.                             0xff, 0xff, 0xff, 0xff, 0x00};
  147. UBYTE cmd_audioOn[10]  =  { 0x4b, 0x00, 0x00, 0x00, 0x00,
  148.                             0x00, 0x00, 0x00, 0x01, 0x00};
  149. UBYTE cmd_audioOff[10] =  { 0x4b, 0x00, 0x00, 0x00, 0x00,
  150.                             0x00, 0x00, 0x00, 0x00, 0x00};
  151. UBYTE cmd_status[10]   =  { 0x42, 0x00, 0x40, 0x01, 0x00,
  152.                             0x00, 0x00, 0x00, 0xff, 0x00};
  153. UBYTE cmd_driveinfo[6] =  { 0x12, 0x00, 0x00, 0x00, 0x90, 0x00 };
  154. UBYTE cmd_modesense[6] =  { 0x1a, 0x00, 0x0e, 0x00, 0xfc, 0x00 };
  155. UBYTE cmd_modeselect[6] = { 0x15, 0x10, 0x00, 0x00, sizeof(struct ModeData), 0x00 };
  156. UBYTE cmd_readtoc[10]=    { 0x43, 0x00, 0x00, 0x00, 0x00,
  157.                             0x00, 0x00, TOC_SIZE>>8, TOC_SIZE & 0xff };
  158.  
  159. struct ThisCD    *ThisCD;
  160. struct ThisDrive *ThisDrive;
  161.  
  162. WORD SCSI(cmd,len,buf,buflen,direction)
  163.  UBYTE *cmd;
  164.  UBYTE *buf;
  165.  LONG   buflen;
  166.  WORD   len,direction;
  167. {
  168.  Einstellungen.SCSI=1;
  169.  
  170.  io->io_Command=HD_SCSICMD;
  171.  io->io_Data=scsi;
  172.  io->io_Length=sizeof(struct SCSICmd);
  173.  
  174.  scsi->scsi_Data=buf;
  175.  scsi->scsi_Length=buflen;
  176.  scsi->scsi_Flags=SCSIF_AUTOSENSE|direction;
  177.  scsi->scsi_SenseData=sense;
  178.  scsi->scsi_SenseLength=18;
  179.  scsi->scsi_SenseActual=0;
  180.  
  181.  scsi->scsi_Command=cmd;
  182.  scsi->scsi_CmdLength=len;
  183.  
  184.  DoIO(io);
  185.  if((io->io_Error>=40)&&(io->io_Error<=44))
  186.    Einstellungen.SCSI=2;
  187.  else if(scsi->scsi_Status!=0)
  188.    Einstellungen.SCSI=0;
  189.  
  190.  return(scsi->scsi_Status);
  191. }
  192.  
  193. int InitSCSI(name,unit)
  194.  UBYTE *name;
  195.  UWORD  unit;
  196. {
  197.  UBYTE errtext[250];
  198.  int   test;
  199.  
  200.  port=CreatePortA(0L,0L);
  201.  if(port==NULL)
  202.   {
  203.    Error(GS(34,"Unable to create a message port for the SCSI driver!"));
  204.    return(1);
  205.   }
  206.  io=CreateExtIOA(port,sizeof(struct IOExtTD));
  207.  if(io==NULL)
  208.   {
  209.    Error(GS(35,"Unable to create a IORequest for the SCSI driver!"));
  210.    return(2);
  211.   }
  212.  dev=OpenDevice(name,unit,io,0);
  213.  if(dev!=0)
  214.   {
  215.    sprintf(&errtext,GS(36,"Unable to open the SCSI driver:\n %s, Unit %d\nOpenDevice()-Error: #%d\n\n Please check the driver's name, unit number and if the drive is turned on!"),
  216.                     name,unit,io->io_Error);
  217.    Error(&errtext);
  218.    return(3);
  219.   }
  220.  buffer=AllocRemember(&Remember,2048,MEMF_CLEAR|MEMF_PUBLIC);
  221.  scsi=AllocRemember(&Remember,sizeof(struct SCSICmd),MEMF_CLEAR|MEMF_PUBLIC);
  222.  sense=AllocRemember(&Remember,18,MEMF_CLEAR|MEMF_PUBLIC);
  223.  ThisCD=AllocRemember(&Remember,sizeof(struct ThisCD),MEMF_ANY);
  224.  ThisDrive=AllocRemember(&Remember,sizeof(struct ThisDrive),MEMF_ANY);
  225.  if((buffer==NULL)||(sense==NULL)||(scsi==NULL)||(ThisCD==NULL)||(ThisDrive==NULL))
  226.   {
  227.    Error(GS(6,"Not enough memory!"));
  228.    return(4);
  229.   }
  230.  Einstellungen.SCSI=1;
  231.  test=SCSI(&cmd_driveinfo,6,buffer,sizeof(struct CDDriveInfo),SCSIF_READ);
  232.  if(Einstellungen.SCSI!=1)
  233.   {
  234.    sprintf(&errtext,GS(37,"The SCSI-drive unit %d doesn't answer the Inquiry command\nDoIO()-Error #%d\nSCSI-Status #%d\nPlease check if the drive is turned on!"),
  235.           unit,io->io_Error,scsi->scsi_Status);
  236.    Error(&errtext);
  237.    return(5);
  238.   }
  239.  if(((struct CDDriveInfo *)buffer)->PeripheralType!=0x05)
  240.   {
  241.    sprintf(&errtext,
  242.            GS(38,"The SCSI-drive unit %d is not a CD-ROM-drive.\nDrive type: #%d"),
  243.           unit,((struct CDDriveInfo *)buffer)->PeripheralType);
  244.    Error(&errtext);
  245.    return(6);
  246.   }
  247.  
  248.  strncpy(&ThisDrive->Vendor,((struct CDDriveInfo *)buffer)->Vendor,8);
  249.  strncpy(&ThisDrive->Product,((struct CDDriveInfo *)buffer)->Product,16);
  250.  strncpy(&ThisDrive->Revision,((struct CDDriveInfo *)buffer)->Revision,4);
  251.  ThisDrive->Vendor[8]=0x00;
  252.  ThisDrive->Product[16]=0x00;
  253.  ThisDrive->Revision[4]=0x00;
  254.  if(!(strncmp(&ThisDrive->Vendor,"TOSHIBA")))
  255.    strcpy(&ThisDrive->Vendor,"Toshiba, Japan");
  256.  if(!(strncmp(&ThisDrive->Product,"CD-ROM XM-3401TA",16)))
  257.    Einstellungen.Toshiba=1;
  258.  
  259.  return(0);
  260. }
  261.  
  262. void EntferneSCSI()
  263. {
  264.  if(dev==0)
  265.   {
  266.    SichereKatalog();
  267.    Einstellungen.Lock=0;
  268.    AuswurfLock();
  269.    CloseDevice(io);
  270.   }
  271.  if(io) DeleteExtIOA(io);
  272.  if(port) DeletePortA(port);
  273.  if(ListRemember) FreeRemember(&ListRemember,TRUE);
  274.  if(Remember) FreeRemember(&Remember,TRUE);
  275. }
  276.  
  277. void LeseStatus()
  278. {
  279.  REGISTER ULONG                 a,b;
  280.  struct TagItem                 tag[2];
  281.  register struct CDStatus      *cd;
  282.  register struct TOCBlock      *toc;
  283.  register int                   i;
  284.  
  285.  if(!(SCSI(&cmd_status,10,buffer,512,SCSIF_READ)))
  286.   {
  287.    cd=buffer;
  288.    switch(cd->AudioStatus)
  289.     {
  290.      case 0x11:
  291.        if(!((Einstellungen.Funktion==VORLAUF)||(Einstellungen.Funktion==RUECKLAUF)))
  292.        Einstellungen.Funktion=WIEDERGABE;
  293.       break;
  294.      case 0x12:
  295.       if((Einstellungen.Funktion!=VORLAUF)&&(Einstellungen.Funktion!=RUECKLAUF))
  296.        Einstellungen.Funktion=PAUSE;
  297.       break;
  298.      case 0x14:
  299.      case 0x13:
  300.        if(Einstellungen.Auswahlmodus==LISTE)
  301.         {
  302.          if(Einstellungen.Track<ThisCD->Anzahl)
  303.           {
  304.            Einstellungen.Track++;
  305.            if(Einstellungen.Track>ThisCD->Anzahl) Einstellungen.Track=1;
  306.            if(Einstellungen.Track<1) Einstellungen.Track=1;
  307.            Einstellungen.Funktion=STOP;
  308.            Wiedergabe();
  309.            Einstellungen.Funktion=WIEDERGABE;
  310.           }
  311.          else
  312.           {
  313.            if(Einstellungen.AutoRepeat)
  314.             {
  315.              Einstellungen.Track=1;
  316.              Wiedergabe();
  317.              Einstellungen.Funktion=WIEDERGABE;
  318.             }
  319.            else
  320.              Einstellungen.Funktion=STOP;
  321.           }
  322.         }
  323.        else
  324.         {
  325.          i=Random(ThisCD->Anzahl);
  326.          Einstellungen.Track=i;
  327.          Einstellungen.Funktion=STOP;
  328.          Wiedergabe();
  329.          Einstellungen.Funktion=WIEDERGABE;
  330.         }
  331.       break;
  332.      case 0x15:
  333.        if(Einstellungen.Funktion==WIEDERGABE) Einstellungen.Funktion=STOP;
  334.       break;
  335.     }
  336.    switch(Einstellungen.Funktion)
  337.     {
  338.      case PLUS:
  339.      case MINUS:
  340.        Einstellungen.Adresse=ThisCD->Track[Einstellungen.Track-1].SAdresse;
  341.        Einstellungen.Funktion=STOP;
  342.       break;
  343.      case VORLAUF:
  344.      case RUECKLAUF:
  345.       break;
  346.      default:
  347.        if(Einstellungen.CDEingelegt)
  348.         {
  349.          if((cd->Track<1)||(cd->Track>ThisCD->Anzahl)) cd->Track=1;
  350.          Einstellungen.Track=MBTab[cd->Track];
  351.          if(cd->Index!=0)
  352.            Einstellungen.Adresse=cd->Adresse;
  353.          else
  354.            Einstellungen.Adresse=ThisCD->Track[Einstellungen.Track-1].SAdresse;
  355.         }
  356.       break;
  357.     }
  358.   }
  359.  
  360.  if(!(SCSI(&cmd_readtoc,10,buffer,TOC_SIZE,SCSIF_READ)))
  361.   {
  362.    if(Einstellungen.CDEingelegt==0)
  363.     {
  364.      Einstellungen.Funktion=STOP;
  365.      Einstellungen.CDEingelegt=1;
  366.      Einstellungen.CDTyp=DATEN;
  367.      Einstellungen.Titel=0;
  368.      toc=buffer;
  369.      ThisCD->ErsterTrack=toc->TOCHeader.FirstTrack;
  370.      ThisCD->LetzterTrack=toc->TOCHeader.LastTrack;
  371.      ThisCD->Anzahl=0;
  372.  
  373.      for(i=0;i<100;i++) { PosTab[i]=0xff; MBTab[i]=0; }
  374.      for(i=0;i<toc->TOCHeader.Length/8;i++)
  375.       {
  376.        MBTab[toc->TOCData[i].TrackNumber]=ThisCD->Anzahl+1;
  377.        if((toc->TOCData[i].TrackNumber!=0xaa) && !(toc->TOCData[i].Flags & 4))
  378.         {
  379.          PosTab[ThisCD->Anzahl]=toc->TOCData[i].TrackNumber;
  380.          a=toc->TOCData[i].Adresse;
  381.          ThisCD->Track[ThisCD->Anzahl].SMinute=(a/75/60);
  382.          ThisCD->Track[ThisCD->Anzahl].SSekunde=((a/75) % 60);
  383.          ThisCD->Track[ThisCD->Anzahl].SFrame=(a % 75);
  384.          ThisCD->Track[ThisCD->Anzahl].SAdresse=a;
  385.          b=toc->TOCData[i+1].Adresse-a;
  386.          ThisCD->Track[ThisCD->Anzahl].TMinute=(b/75/60);
  387.          ThisCD->Track[ThisCD->Anzahl].TSekunde=((b/75) % 60);
  388.          ThisCD->Track[ThisCD->Anzahl].TFrame=(b % 75);
  389.          ThisCD->Track[ThisCD->Anzahl].TAdresse=b;
  390.          ThisCD->Anzahl++;
  391.          Einstellungen.CDTyp=AUDIO;
  392.         }
  393.       }
  394.  
  395.      if(Einstellungen.CDTyp==DATEN)
  396.        Einstellungen.Funktion=STANDBY;
  397.      else
  398.       {
  399.        SleepPointer(CDPlayerWnd);
  400.        ThisCD->Endadresse=ThisCD->Track[ThisCD->Anzahl-1].SAdresse+ThisCD->Track[ThisCD->Anzahl-1].TAdresse;
  401.        ThisCD->Startadresse=ThisCD->Track[0].SAdresse;
  402.        ThisCD->ID=ThisCD->Anzahl*ThisCD->Endadresse;
  403.  
  404.        Einstellungen.CDKatalogisiert=LadeKatalog();
  405.  
  406.        ListeErstellen();
  407.        SetzeLR();
  408.        Volumen();
  409.        AuswurfLock();
  410.  
  411.        Einstellungen.Track=1;
  412.        Einstellungen.Adresse=0;
  413.  
  414.        if((Einstellungen.AutoStart)&&(Einstellungen.Funktion!=WIEDERGABE))
  415.         {
  416.          Einstellungen.Funktion=AUTO;
  417.          Symbol(AUTO);
  418.          Einstellungen.AutoCnt=1;
  419.         }
  420.        ClearPointer(CDPlayerWnd);
  421.       }
  422.     }
  423.   }
  424.  else
  425.    ListeEntfernen();
  426.  
  427.  if(Einstellungen.Funktion==VORLAUF)
  428.   {
  429.    Einstellungen.Adresse+=25;
  430.    if(Einstellungen.Adresse>ThisCD->Endadresse)
  431.     {
  432.      Einstellungen.Adresse=ThisCD->Endadresse;
  433.      Einstellungen.Funktion=STOP;
  434.     }
  435.  
  436.    a=Einstellungen.Adresse;
  437.    if(Einstellungen.Track<ThisCD->Anzahl)
  438.     {
  439.      if(a>=ThisCD->Track[Einstellungen.Track].SAdresse)
  440.       Einstellungen.Track++;
  441.     }
  442.    a-=ThisCD->Track[Einstellungen.Track-1].SAdresse;
  443.   }
  444.  else if(Einstellungen.Funktion==RUECKLAUF)
  445.   {
  446.    if(Einstellungen.Adresse>=25)
  447.      Einstellungen.Adresse-=25;
  448.    else
  449.     {
  450.      Einstellungen.Adresse=0;
  451.      Einstellungen.Funktion=STOP;
  452.     }
  453.    a=Einstellungen.Adresse;
  454.    if(Einstellungen.Track>1)
  455.     {
  456.      if(a<ThisCD->Track[Einstellungen.Track-1].SAdresse)
  457.       Einstellungen.Track--;
  458.     }
  459.    a-=ThisCD->Track[Einstellungen.Track-1].SAdresse;
  460.   }
  461. }
  462.  
  463. void Auswurf()
  464. {
  465.  ListeEntfernen();
  466.  SCSI(&cmd_eject,10,0,0,SCSIF_WRITE);
  467. }
  468.  
  469. void Stop()
  470. {
  471.  Einstellungen.Adresse=ThisCD->Track[Einstellungen.Track-1].SAdresse;
  472.  SCSI(&cmd_stop,6,0,0,SCSIF_WRITE);
  473. }
  474.  
  475. void Pause()
  476. {
  477.  SCSI(&cmd_audioOff,10,buffer,0,SCSIF_WRITE);
  478.  LeseStatus();
  479. }
  480.  
  481. void SetzeLR()
  482. {
  483.  REGISTER UBYTE  *m;
  484.  struct ModeData  modedata;
  485.  register int     i;
  486.  
  487.  for(i=0;i<4;i++) modedata.Head[i]=0;
  488.  if(!(SCSI(&cmd_modesense,6,buffer,252,SCSIF_READ)))
  489.   {
  490.    i=buffer[3]+4;
  491.    CopyMem(&buffer[i],&modedata.Page,16);
  492.  
  493.    modedata.Out0=Einstellungen.AudioL;
  494.    modedata.Out1=Einstellungen.AudioR;
  495.  
  496.    SCSI(&cmd_modeselect,6,&modedata,sizeof(struct ModeData),SCSIF_WRITE);
  497.   }
  498. }
  499.  
  500. void Wiedergabe()
  501. {
  502.  if(Einstellungen.Funktion==PAUSE)
  503.    SCSI(&cmd_audioOn,10,buffer,0,SCSIF_WRITE);
  504.  else if((Einstellungen.Funktion==VORLAUF)||(Einstellungen.Funktion==RUECKLAUF))
  505.    Continue();
  506.  else
  507.   {
  508.    Einstellungen.Adresse=ThisCD->Track[Einstellungen.Track-1].SAdresse;
  509.    cmd_play[4]=PosTab[Einstellungen.Track-1];
  510.    cmd_play[7]=cmd_play[4];
  511.    cmd_play[8]=99;
  512.    SCSI(&cmd_play,10,0,0,SCSIF_WRITE);
  513.   }
  514. }
  515.  
  516. void Continue()
  517. {
  518.  REGISTER ULONG a;
  519.  
  520.  SCSI(&cmd_audioOff,10,buffer,0,SCSIF_WRITE);
  521.  a=Einstellungen.Adresse+150;
  522.  cmd_playfrom[3]=a/75/60;
  523.  cmd_playfrom[4]=(a/75) % 60;
  524.  cmd_playfrom[5]=a % 75;
  525.  a=ThisCD->Track[Einstellungen.Track-1].TAdresse+
  526.    ThisCD->Track[Einstellungen.Track-1].SAdresse;
  527.  cmd_playfrom[6]=a/75/60;
  528.  cmd_playfrom[7]=(a/75) % 60;
  529.  cmd_playfrom[8]=a % 75;
  530.  SCSI(&cmd_playfrom,10,buffer,2048,SCSIF_WRITE);
  531.  SCSI(&cmd_audioOn,10,buffer,0,SCSIF_WRITE);
  532.  SetzeLR();
  533. }
  534.  
  535. void Volumen()
  536. {
  537.  REGISTER UBYTE  *m;
  538.  struct ModeData  modedata;
  539.  register int     i;
  540.  
  541.  for(i=0;i<4;i++) modedata.Head[i]=0;
  542.  if(!(SCSI(&cmd_modesense,6,buffer,252,SCSIF_READ)))
  543.   {
  544.    i=buffer[3]+4;
  545.    CopyMem(&buffer[i],&modedata.Page,16);
  546.  
  547.    modedata.Vol0=Einstellungen.VolumenL;
  548.    modedata.Vol1=Einstellungen.VolumenR;
  549.  
  550.    SCSI(&cmd_modeselect,6,&modedata,sizeof(struct ModeData),SCSIF_WRITE);
  551.   }
  552. }
  553.  
  554. void AuswurfLock()
  555. {
  556.  cmd_lock[4]=Einstellungen.Lock;
  557.  SCSI(&cmd_lock,6,0,0,SCSIF_WRITE);
  558. }
  559.  
  560. void ListeEntfernen()
  561. {
  562.  register struct StringInfo *si;
  563.  struct          TagItem     tag[2];
  564.  
  565.  Einstellungen.CDKatalogisiert=SichereKatalog();
  566.  Einstellungen.Auswahl=255;
  567.  Einstellungen.Titel=0;
  568.  Einstellungen.CDEingelegt=0;
  569.  Einstellungen.Funktion=STANDBY;
  570.  Einstellungen.CDKatalogisiert=0;
  571.  Einstellungen.NumS=0;
  572.  if(ListRemember)
  573.   {
  574.    FreeRemember(&ListRemember,TRUE);
  575.    ListRemember=NULL;
  576.    NewListA(&Liste);
  577.    if(IsIconify==FALSE)
  578.     {
  579.      si=CDPlayerGadgets[24]->SpecialInfo;
  580.      strcpy(si->Buffer,"");
  581.      RefreshGList(CDPlayerGadgets[24],CDPlayerWnd,NULL,1L);
  582.      tag[0].ti_Tag=GTLV_Labels;
  583.      tag[0].ti_Data=&Liste;
  584.      tag[1].ti_Tag=TAG_DONE;
  585.      GTSetGadgetAttrsA(CDPlayerGadgets[0],CDPlayerWnd,NULL,&tag);
  586.     }
  587.   } 
  588. }
  589.  
  590. void ListeErstellen()
  591. {
  592.  struct TagItem         tag[2];
  593.  register int           i;
  594.  register struct Liste *li;
  595.  
  596.  if(!(Einstellungen.CDEingelegt)) return;
  597.  if(!(Einstellungen.CDTyp==AUDIO)) return;
  598.  
  599.  NewListA(&Liste);
  600.  if(ListRemember) FreeRemember(&ListRemember,TRUE);
  601.  ListRemember=NULL;
  602.  Einstellungen.Auswahl=255;
  603.  Einstellungen.Titel=0;
  604.  
  605.  for(i=0;i<=ThisCD->Anzahl;i++)
  606.   {
  607.    li=AllocRemember(&ListRemember,sizeof(struct ListenEintrag),MEMF_ANY);
  608.    if(li!=NULL)
  609.     {
  610.      li->Node.ln_Succ=NULL;
  611.      li->Node.ln_Pred=NULL;
  612.      li->Node.ln_Type=0;
  613.      li->Node.ln_Pri=0;
  614.      li->Node.ln_Name=&li->Text;
  615.      if(i<ThisCD->Anzahl)
  616.       {
  617.        if(LowRes==FALSE)
  618.          sprintf(&li->Text,"%02d  %s",i+1,&Katalog->KE[i].Titel);
  619.        else
  620.          sprintf(&li->Text,"%02d %s",i+1,&Katalog->KE[i].Titel);
  621.      AddTail(&Liste,li);
  622.       }
  623.      else
  624.       {
  625.        sprintf(&li->Text,"%s:",&Katalog->CDName);
  626.        AddHead(&Liste,li);
  627.       }
  628.     }
  629.   }
  630.  if(IsIconify==FALSE)
  631.   {
  632.    tag[0].ti_Tag=GTLV_Labels;
  633.    tag[0].ti_Data=&Liste;
  634.    tag[1].ti_Tag=TAG_DONE;
  635.    GTSetGadgetAttrsA(CDPlayerGadgets[0],CDPlayerWnd,NULL,&tag);
  636.   }
  637. }
  638.  
  639. void LeereKatalog()
  640. {
  641.  register int i;
  642.  
  643.  Katalog->ID[0]='D';
  644.  Katalog->ID[1]='I';
  645.  Katalog->ID[2]='S';
  646.  Katalog->ID[3]='C';
  647.  Katalog->KatalogVersion=VERSION;
  648.  Katalog->Anzahl=ThisCD->Anzahl;
  649.  Katalog->DiscID=ThisCD->ID;
  650.  strcpy(&Katalog->CDName,"Unbenannt");
  651.  for(i=0;i<ThisCD->Anzahl;i++)
  652.   {
  653.    Katalog->KE[i].SAdresse=ThisCD->Track[i].SAdresse;
  654.    Katalog->KE[i].TAdresse=ThisCD->Track[i].TAdresse;
  655.    sprintf(&Katalog->KE[i].Titel,
  656.            "Track #%d    %2d:%02d'%02d",
  657.            i+1,
  658.            ThisCD->Track[i].TMinute,
  659.            ThisCD->Track[i].TSekunde,
  660.            ThisCD->Track[i].TFrame);
  661.   }
  662. }
  663.  
  664. UBYTE LadeKatalog()
  665. {
  666.  UBYTE                       name[80];
  667.  register struct FileHandle *fh;
  668.  register int                i;
  669.  
  670.  sprintf(&name,"AudioCD:AudioCD-ID#%08lx",ThisCD->ID);
  671.  fh=Open(&name,MODE_OLDFILE);
  672.  if(fh!=NULL)
  673.   {
  674.    Katalog->Anzahl=99;
  675.    Read(fh,Katalog,KSIZE(Katalog));
  676.    Close(fh);
  677.    if(!(strncmp(&Katalog->ID,"DISC",4)))
  678.     {
  679.      if(ThisCD->ID==Katalog->DiscID)
  680.       {
  681.        /* Zeitdaten in Katalogdatei falls nötig korrigieren */
  682.        for(i=0;i<ThisCD->Anzahl;i++)
  683.         {
  684.          if(Katalog->KE[i].SAdresse!=ThisCD->Track[i].SAdresse)
  685.           { Katalog->KE[i].SAdresse=ThisCD->Track[i].SAdresse; Einstellungen.CatChange=1; }
  686.          if(Katalog->KE[i].TAdresse!=ThisCD->Track[i].TAdresse)
  687.           { Katalog->KE[i].TAdresse=ThisCD->Track[i].TAdresse; Einstellungen.CatChange=1; }
  688.         }
  689.        /* ------------------------------------------------- */
  690.        return(1);
  691.       }
  692.     }
  693.   }
  694.  LeereKatalog();
  695.  return(0);
  696. }
  697.  
  698. UBYTE SichereKatalog()
  699. {
  700.  UBYTE                      *ttArray[5];
  701.  UBYTE                       name[80];
  702.  register struct DiskObject *di;
  703.  register struct FileHandle *fh;
  704.  
  705.  if(Einstellungen.CatChange)
  706.   {
  707.    Einstellungen.CatChange=0;
  708.    if(Einstellungen.AutoSave==0)
  709.     {
  710.      if(!(MultiRequest(GS(44,"Save catalog..."),
  711.                        GS(46,"Do you want to save the catalog?"),
  712.                        GS(47,"Yes, save|No!")))) return;
  713.     }
  714.  
  715.    SleepPointer(CDPlayerWnd);
  716.    sprintf(&name,"AudioCD:AudioCD-ID#%08lx",Katalog->DiscID);
  717.    fh=Open(&name,MODE_NEWFILE);
  718.    if(fh==NULL) return(0);
  719.  
  720.    Write(fh,Katalog,KSIZE(Katalog));
  721.    Close(fh);
  722.  
  723.    di=GetDiskObject(&name);
  724.    if(di!=NULL)
  725.     {
  726.      AudioCD.do_CurrentX=di->do_CurrentX;
  727.      AudioCD.do_CurrentY=di->do_CurrentY;
  728.      FreeDiskObject(di);
  729.     }
  730.  
  731.    ttArray[0]=&Katalog->CDName;
  732.    ttArray[1]="*** This file was created by";
  733.    ttArray[2]="*** MusicBox, written by";
  734.    ttArray[3]="*** Thomas Dreibholz";
  735.    ttArray[4]=NULL;
  736.    AudioCD.do_ToolTypes=&ttArray;
  737.    PutDiskObject(&name,&AudioCD);
  738.    ClearPointer(CDPlayerWnd);
  739.  
  740.    return(1);
  741.   }
  742. }
  743.  
  744.